import { MemoryRecord, ErrorPattern } from './types.js';

/**
 * 记忆分析器类
 * 负责分析错误模式、生成经验总结和分析思考过程
 */
export class MemoryAnalyzer {
    /**
     * 提取错误模式
     * @param errorContent 错误内容
     * @returns 提取的错误模式
     */
    static extractErrorPattern(errorContent: string): string {
        // 简化版的错误模式提取
        const lines = errorContent.split('\n');
        const firstLine = lines[0].trim();

        // 移除特定的错误信息，保留模式
        return firstLine
            .replace(/\d+/g, 'N') // 替换数字
            .replace(/(['"]).*?\1/g, '$1STR$1') // 替换字符串
            .replace(/\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/g, 'EMAIL') // 替换邮箱
            .substring(0, 100); // 限制长度
    }

    /**
     * 分析错误模式
     * @param patterns 错误模式列表
     * @returns 分析报告
     */
    static analyzeErrorPatterns(patterns: ErrorPattern[]): string {
        if (patterns.length === 0) {
            return "没有发现错误模式。";
        }

        // 按频率排序
        patterns.sort((a, b) => b.frequency - a.frequency);

        // 生成分析报告
        let report = `# 错误模式分析报告\n\n`;
        report += `共发现 ${patterns.length} 种错误模式。\n\n`;

        report += `## 常见错误模式\n\n`;
        patterns.forEach((pattern, index) => {
            report += `### ${index + 1}. 错误模式: ${pattern.pattern}\n`;
            report += `- 出现频率: ${pattern.frequency} 次\n`;
            report += `- 最后更新: ${new Date(pattern.lastUpdated).toLocaleString()}\n`;

            if (pattern.solutions) {
                report += `- 解决方案:\n${pattern.solutions}\n`;
            } else {
                report += `- 解决方案: 暂无\n`;

                // 为常见错误模式生成建议的解决方案
                const suggestedSolution = this.suggestSolution(pattern.pattern);
                if (suggestedSolution) {
                    report += `- 建议解决方案:\n${suggestedSolution}\n`;
                }
            }
            report += `\n`;
        });

        // 添加总结和建议
        report += `## 总结与建议\n\n`;

        // 找出最常见的错误模式
        const mostCommonPattern = patterns[0];
        report += `最常见的错误模式是 "${mostCommonPattern.pattern}"，出现了 ${mostCommonPattern.frequency} 次。\n\n`;

        // 根据错误模式提供一般性建议
        report += this.generateGeneralAdvice(patterns);

        return report;
    }

    /**
     * 根据错误模式提供解决方案建议
     * @param pattern 错误模式
     * @returns 建议的解决方案
     */
    private static suggestSolution(pattern: string): string | null {
        // 这里可以实现更复杂的解决方案推荐逻辑
        // 目前只是一个简单的示例
        if (pattern.includes('TypeError')) {
            return "检查变量类型是否正确，确保在使用变量之前已经定义和初始化。";
        } else if (pattern.includes('SyntaxError')) {
            return "检查代码语法，可能存在括号不匹配、缺少分号或其他语法错误。";
        } else if (pattern.includes('ReferenceError')) {
            return "检查变量是否已定义，可能使用了未声明的变量或超出作用域的变量。";
        } else if (pattern.includes('permission')) {
            return "检查文件或资源的权限设置，确保有足够的访问权限。";
        }

        return null;
    }

    /**
     * 生成一般性建议
     * @param patterns 错误模式列表
     * @returns 一般性建议
     */
    private static generateGeneralAdvice(patterns: ErrorPattern[]): string {
        let advice = "";

        // 检查是否有类型错误
        const typeErrors = patterns.filter(p => p.pattern.includes('TypeError'));
        if (typeErrors.length > 0) {
            advice += "- **类型错误**: 发现多个类型相关的错误，建议加强类型检查，考虑使用TypeScript或增加类型验证。\n\n";
        }

        // 检查是否有语法错误
        const syntaxErrors = patterns.filter(p => p.pattern.includes('SyntaxError'));
        if (syntaxErrors.length > 0) {
            advice += "- **语法错误**: 发现多个语法错误，建议使用代码检查工具如ESLint或使用IDE的语法检查功能。\n\n";
        }

        // 检查是否有引用错误
        const referenceErrors = patterns.filter(p => p.pattern.includes('ReferenceError'));
        if (referenceErrors.length > 0) {
            advice += "- **引用错误**: 发现多个变量引用错误，建议在使用变量前确保其已定义，并注意变量的作用域。\n\n";
        }

        // 检查是否有权限错误
        const permissionErrors = patterns.filter(p => p.pattern.includes('permission') || p.pattern.includes('EACCES'));
        if (permissionErrors.length > 0) {
            advice += "- **权限错误**: 发现多个权限相关错误，建议检查文件和资源的访问权限，可能需要提升权限或修改文件权限设置。\n\n";
        }

        // 如果没有特定建议，提供一般性建议
        if (!advice) {
            advice = "根据错误模式分析，建议加强代码审查和测试，特别关注错误处理和异常捕获机制。定期检查日志，及时发现和解决问题。\n\n";
        }

        return advice;
    }

    /**
     * 生成经验总结
     * @param experiences 经验记录列表
     * @param topic 主题
     * @returns 经验总结
     */
    static generateExperienceSummary(experiences: MemoryRecord[], topic?: string): string {
        if (experiences.length === 0) {
            return '没有找到相关经验记录';
        }

        // 简单汇总经验
        const summary = `
# AI 经验总结${topic ? ` - ${topic}` : ''}

## 主要经验点

${experiences.map((exp, index) => `${index + 1}. ${exp.content.split('\n')[0]}`).join('\n')}

## 详细经验

${experiences.map((exp, index) => `### 经验 ${index + 1}\n${exp.content}\n\n**上下文:** ${exp.context || '无'}\n\n**记录时间:** ${new Date(exp.timestamp).toLocaleString()}\n\n**标签:** ${exp.tags || '无'}\n\n---\n`).join('\n')}
`;

        return summary;
    }

    /**
     * 分析思考过程
     * @param thoughts 思考记录列表
     * @returns 分析报告
     */
    static analyzeThoughts(thoughts: MemoryRecord[]): string {
        if (thoughts.length === 0) {
            return '没有找到思考记录';
        }

        // 提取思考中的关键词和主题
        const keywordMap = new Map<string, number>();
        const topics = new Set<string>();

        thoughts.forEach(thought => {
            // 提取标签作为主题
            if (thought.tags) {
                thought.tags.split(',').forEach(tag => {
                    topics.add(tag.trim());
                });
            }

            // 提取关键词
            const content = thought.content.toLowerCase();
            const words = content.split(/\s+/);

            words.forEach(word => {
                // 过滤掉常见的停用词和短词
                if (word.length > 3 && !this.isStopWord(word)) {
                    keywordMap.set(word, (keywordMap.get(word) || 0) + 1);
                }
            });
        });

        // 按频率排序关键词
        const sortedKeywords = Array.from(keywordMap.entries())
            .sort((a, b) => b[1] - a[1])
            .slice(0, 10);

        // 生成分析报告
        let report = `# 思考过程分析报告\n\n`;
        report += `分析了 ${thoughts.length} 条思考记录。\n\n`;

        // 添加时间分布
        report += `## 时间分布\n\n`;
        const timeDistribution = this.analyzeTimeDistribution(thoughts);
        report += timeDistribution;

        // 添加主题分布
        report += `## 主题分布\n\n`;
        if (topics.size > 0) {
            report += `发现的主题: ${Array.from(topics).join(', ')}\n\n`;
        } else {
            report += `未发现明确的主题标签。\n\n`;
        }

        // 添加关键词分析
        report += `## 关键词分析\n\n`;
        if (sortedKeywords.length > 0) {
            report += `最常见的关键词:\n\n`;
            sortedKeywords.forEach(([keyword, count]) => {
                report += `- ${keyword}: ${count} 次\n`;
            });
            report += `\n`;
        } else {
            report += `未发现显著的关键词。\n\n`;
        }

        // 添加思考模式分析
        report += `## 思考模式分析\n\n`;
        const patternAnalysis = this.analyzeThinkingPatterns(thoughts);
        report += patternAnalysis;

        // 添加建议
        report += `## 建议\n\n`;
        report += this.generateThinkingAdvice(thoughts, sortedKeywords);

        return report;
    }

    /**
     * 分析时间分布
     * @param thoughts 思考记录列表
     * @returns 时间分布分析
     */
    private static analyzeTimeDistribution(thoughts: MemoryRecord[]): string {
        // 按日期分组
        const dateMap = new Map<string, number>();

        thoughts.forEach(thought => {
            const date = new Date(thought.timestamp).toLocaleDateString();
            dateMap.set(date, (dateMap.get(date) || 0) + 1);
        });

        // 按日期排序
        const sortedDates = Array.from(dateMap.entries())
            .sort((a, b) => new Date(a[0]).getTime() - new Date(b[0]).getTime());

        let result = "";

        if (sortedDates.length > 0) {
            result += "思考记录的日期分布:\n\n";
            sortedDates.forEach(([date, count]) => {
                result += `- ${date}: ${count} 条记录\n`;
            });
            result += `\n`;

            // 分析思考频率
            const totalDays = sortedDates.length;
            const totalThoughts = thoughts.length;
            const averagePerDay = totalThoughts / totalDays;

            result += `平均每天 ${averagePerDay.toFixed(2)} 条思考记录。\n\n`;

            // 找出思考最多的日期
            const maxThoughtsDate = sortedDates.reduce((max, current) =>
                current[1] > max[1] ? current : max
            );

            result += `思考最活跃的日期是 ${maxThoughtsDate[0]}，有 ${maxThoughtsDate[1]} 条记录。\n\n`;
        } else {
            result += "无法分析时间分布。\n\n";
        }

        return result;
    }

    /**
     * 分析思考模式
     * @param thoughts 思考记录列表
     * @returns 思考模式分析
     */
    private static analyzeThinkingPatterns(thoughts: MemoryRecord[]): string {
        // 分析思考的长度
        const lengthStats = thoughts.reduce(
            (stats, thought) => {
                const length = thought.content.length;
                return {
                    total: stats.total + length,
                    min: Math.min(stats.min, length),
                    max: Math.max(stats.max, length),
                };
            },
            { total: 0, min: Infinity, max: 0 }
        );

        const averageLength = lengthStats.total / thoughts.length;

        let result = `思考记录的平均长度为 ${averageLength.toFixed(2)} 个字符，最短 ${lengthStats.min} 个字符，最长 ${lengthStats.max} 个字符。\n\n`;

        // 分析思考的复杂度（简单使用句子数量作为指标）
        const complexityStats = thoughts.reduce(
            (stats, thought) => {
                const sentences = thought.content.split(/[.!?。！？]+/).length;
                return {
                    total: stats.total + sentences,
                    min: Math.min(stats.min, sentences),
                    max: Math.max(stats.max, sentences),
                };
            },
            { total: 0, min: Infinity, max: 0 }
        );

        const averageComplexity = complexityStats.total / thoughts.length;

        result += `思考记录的平均复杂度为 ${averageComplexity.toFixed(2)} 个句子，最简单 ${complexityStats.min} 个句子，最复杂 ${complexityStats.max} 个句子。\n\n`;

        // 分析思考的情感倾向
        const sentimentStats = this.analyzeSentiment(thoughts);
        result += `思考记录的情感倾向分析：\n`;
        result += `- 积极: ${sentimentStats.positive} 条\n`;
        result += `- 中性: ${sentimentStats.neutral} 条\n`;
        result += `- 消极: ${sentimentStats.negative} 条\n\n`;

        return result;
    }

    /**
     * 分析情感倾向
     * @param thoughts 思考记录列表
     * @returns 情感统计
     */
    private static analyzeSentiment(thoughts: MemoryRecord[]): {
        positive: number;
        neutral: number;
        negative: number;
    } {
        const positiveWords = new Set([
            'success', 'successful', 'succeed', 'good', 'great', 'excellent',
            'improve', 'improved', 'better', 'best', 'solved', 'solution',
            'achievement', 'progress', 'positive', 'optimistic', 'effective',
            '成功', '良好', '优秀', '改进', '解决', '进展', '积极', '有效'
        ]);

        const negativeWords = new Set([
            'fail', 'failed', 'failure', 'error', 'problem', 'issue', 'bug',
            'difficult', 'hard', 'complex', 'confusing', 'confused', 'wrong',
            'bad', 'worse', 'worst', 'negative', 'pessimistic', 'ineffective',
            '失败', '错误', '问题', '困难', '复杂', '混乱', '消极', '无效'
        ]);

        return thoughts.reduce(
            (stats, thought) => {
                const content = thought.content.toLowerCase();
                const positiveCount = Array.from(positiveWords).filter(word =>
                    content.includes(word.toLowerCase())
                ).length;
                const negativeCount = Array.from(negativeWords).filter(word =>
                    content.includes(word.toLowerCase())
                ).length;

                if (positiveCount > negativeCount) {
                    stats.positive++;
                } else if (negativeCount > positiveCount) {
                    stats.negative++;
                } else {
                    stats.neutral++;
                }

                return stats;
            },
            { positive: 0, neutral: 0, negative: 0 }
        );
    }

    /**
     * 生成思考建议
     * @param thoughts 思考记录列表
     * @param keywords 关键词列表
     * @returns 建议
     */
    private static generateThinkingAdvice(
        thoughts: MemoryRecord[],
        keywords: [string, number][]
    ): string {
        let advice = '';

        // 基于思考记录数量的建议
        if (thoughts.length < 5) {
            advice += '- 建议增加思考记录的频率，以便更好地追踪和分析思维过程。\n\n';
        }

        // 基于关键词的建议
        if (keywords.length > 0) {
            advice += '- 根据关键词分析，建议关注以下主题：\n';
            keywords.slice(0, 3).forEach(([keyword]) => {
                advice += `  * "${keyword}" 相关的思考和探索\n`;
            });
            advice += '\n';
        }

        // 基于情感分析的建议
        const sentiment = this.analyzeSentiment(thoughts);
        if (sentiment.negative > sentiment.positive) {
            advice += '- 注意到思考倾向偏消极，建议：\n';
            advice += '  * 在思考问题时也关注积极的解决方案\n';
            advice += '  * 记录成功经验和有效方法\n';
            advice += '  * 保持建设性的思维方式\n\n';
        }

        // 基于思考复杂度的建议
        const complexityStats = thoughts.reduce(
            (stats, thought) => {
                const sentences = thought.content.split(/[.!?。！？]+/).length;
                return {
                    total: stats.total + sentences,
                    count: stats.count + 1,
                };
            },
            { total: 0, count: 0 }
        );

        const avgComplexity = complexityStats.total / complexityStats.count;
        if (avgComplexity < 3) {
            advice += '- 思考记录偏简单，建议：\n';
            advice += '  * 深入分析问题的不同方面\n';
            advice += '  * 考虑多个可能的解决方案\n';
            advice += '  * 记录决策过程和理由\n\n';
        }

        // 通用建议
        advice += '- 持续改进建议：\n';
        advice += '  * 定期回顾和总结思考记录\n';
        advice += '  * 建立思考主题的关联性\n';
        advice += '  * 跟踪长期思维模式的变化\n';

        return advice;
    }

    /**
     * 检查是否为停用词
     * @param word 单词
     * @returns 是否为停用词
     */
    private static isStopWord(word: string): boolean {
        const stopWords = new Set([
            'the', 'be', 'to', 'of', 'and', 'a', 'in', 'that', 'have', 'i',
            'it', 'for', 'not', 'on', 'with', 'he', 'as', 'you', 'do', 'at',
            'this', 'but', 'his', 'by', 'from', 'they', 'we', 'say', 'her', 'she',
            'or', 'an', 'will', 'my', 'one', 'all', 'would', 'there', 'their', 'what',
            '的', '了', '是', '在', '和', '有', '我', '你', '他', '她', '它', '这',
            '那', '都', '也', '就', '要', '会', '到', '可以'
        ]);

        return stopWords.has(word.toLowerCase());
    }
}